cshape 0.1.0__tar.gz → 0.2.2__tar.gz

{cshape-0.1.0 → cshape-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cshape
-Version: 0.1.0
+Version: 0.2.2
 Summary: A dependency-free C AST + printer: build a tree in Python, get C11 source back
 Author-email: Alex Balan <outsiders.b@gmail.com>
 License-Expression: MIT
@@ -38,14 +38,14 @@ pip install cshape
 from cshape import *
 
 func = CStmtDefFunc(
-	id_str="add",
-	type=CTypeFunc(
-		params=[CField(id_str="a", type=CTypeNamed("int")),
-		        CField(id_str="b", type=CTypeNamed("int"))],
-		to=CTypeNamed("int"),
+	id="add",
+	type=CTypeFunction(
+		params=[CField(id="a", type=CTypeIdentifier("int")),
+		        CField(id="b", type=CTypeIdentifier("int"))],
+		to=CTypeIdentifier("int"),
 	),
 	block=CStmtBlock([
-		CStmtReturn(CValueAdd(CValueNamed("a"), CValueNamed("b"))),
+		CStmtReturn(CValueAdd(CValueIdentifier("a"), CValueIdentifier("b"))),
 	]),
 )
 
@@ -62,6 +62,12 @@ int add(int a, int b) {
 starts with a blank line by default, so `.strip()` if you're printing a
 single node standalone rather than concatenating several.)
 
+## Documentation
+
+- [docs/api.md](docs/api.md) - documentation index
+- [docs/quickstart.md](docs/quickstart.md) - getting started and first example
+- [docs/reference.md](docs/reference.md) - current API reference
+
 ## What it covers
 
 - Types: named types, pointers, arrays, function types, structs/unions, enums
@@ -77,6 +83,9 @@ single node standalone rather than concatenating several.)
 - A `.mark` field on every node: set it to any string and it shows up as a
   `/*mark*/` comment right before that node in the output — useful for
   tracing which part of your own compiler/generator produced which bit of C
+- A `.note` field on every value, printed as a `/* note */` comment *after*
+  the value — for saying where a value came from once it no longer shows:
+  `3.125 /* totalVolume / elementVolume */`
 
 ## What it doesn't do
 

{cshape-0.1.0 → cshape-0.2.2}/README.md

@@ -20,14 +20,14 @@ pip install cshape
 from cshape import *
 
 func = CStmtDefFunc(
-	id_str="add",
-	type=CTypeFunc(
-		params=[CField(id_str="a", type=CTypeNamed("int")),
-		        CField(id_str="b", type=CTypeNamed("int"))],
-		to=CTypeNamed("int"),
+	id="add",
+	type=CTypeFunction(
+		params=[CField(id="a", type=CTypeIdentifier("int")),
+		        CField(id="b", type=CTypeIdentifier("int"))],
+		to=CTypeIdentifier("int"),
 	),
 	block=CStmtBlock([
-		CStmtReturn(CValueAdd(CValueNamed("a"), CValueNamed("b"))),
+		CStmtReturn(CValueAdd(CValueIdentifier("a"), CValueIdentifier("b"))),
 	]),
 )
 
@@ -44,6 +44,12 @@ int add(int a, int b) {
 starts with a blank line by default, so `.strip()` if you're printing a
 single node standalone rather than concatenating several.)
 
+## Documentation
+
+- [docs/api.md](docs/api.md) - documentation index
+- [docs/quickstart.md](docs/quickstart.md) - getting started and first example
+- [docs/reference.md](docs/reference.md) - current API reference
+
 ## What it covers
 
 - Types: named types, pointers, arrays, function types, structs/unions, enums
@@ -59,6 +65,9 @@ single node standalone rather than concatenating several.)
 - A `.mark` field on every node: set it to any string and it shows up as a
   `/*mark*/` comment right before that node in the output — useful for
   tracing which part of your own compiler/generator produced which bit of C
+- A `.note` field on every value, printed as a `/* note */` comment *after*
+  the value — for saying where a value came from once it no longer shows:
+  `3.125 /* totalVolume / elementVolume */`
 
 ## What it doesn't do
 

{cshape-0.1.0 → cshape-0.2.2}/cshape.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cshape
-Version: 0.1.0
+Version: 0.2.2
 Summary: A dependency-free C AST + printer: build a tree in Python, get C11 source back
 Author-email: Alex Balan <outsiders.b@gmail.com>
 License-Expression: MIT
@@ -38,14 +38,14 @@ pip install cshape
 from cshape import *
 
 func = CStmtDefFunc(
-	id_str="add",
-	type=CTypeFunc(
-		params=[CField(id_str="a", type=CTypeNamed("int")),
-		        CField(id_str="b", type=CTypeNamed("int"))],
-		to=CTypeNamed("int"),
+	id="add",
+	type=CTypeFunction(
+		params=[CField(id="a", type=CTypeIdentifier("int")),
+		        CField(id="b", type=CTypeIdentifier("int"))],
+		to=CTypeIdentifier("int"),
 	),
 	block=CStmtBlock([
-		CStmtReturn(CValueAdd(CValueNamed("a"), CValueNamed("b"))),
+		CStmtReturn(CValueAdd(CValueIdentifier("a"), CValueIdentifier("b"))),
 	]),
 )
 
@@ -62,6 +62,12 @@ int add(int a, int b) {
 starts with a blank line by default, so `.strip()` if you're printing a
 single node standalone rather than concatenating several.)
 
+## Documentation
+
+- [docs/api.md](docs/api.md) - documentation index
+- [docs/quickstart.md](docs/quickstart.md) - getting started and first example
+- [docs/reference.md](docs/reference.md) - current API reference
+
 ## What it covers
 
 - Types: named types, pointers, arrays, function types, structs/unions, enums
@@ -77,6 +83,9 @@ single node standalone rather than concatenating several.)
 - A `.mark` field on every node: set it to any string and it shows up as a
   `/*mark*/` comment right before that node in the output — useful for
   tracing which part of your own compiler/generator produced which bit of C
+- A `.note` field on every value, printed as a `/* note */` comment *after*
+  the value — for saying where a value came from once it no longer shows:
+  `3.125 /* totalVolume / elementVolume */`
 
 ## What it doesn't do
 

{cshape-0.1.0 → cshape-0.2.2}/cshape.py

@@ -1,11 +1,31 @@
 
+
 nl_symbol = "\n"
 indent_symbol = "\t"
-
 indent_level = 0
 
 
 
+legacy_style = {
+	'LINE_BREAK_BEFORE_STRUCT_BRACE': False,
+	'LINE_BREAK_BEFORE_FUNC_BRACE': False,
+	'LINE_BREAK_BEFORE_BLOCK_BRACE': False,
+}
+
+modern_style = {
+	'LINE_BREAK_BEFORE_STRUCT_BRACE': True,
+	'LINE_BREAK_BEFORE_FUNC_BRACE': True,
+	'LINE_BREAK_BEFORE_BLOCK_BRACE': True,
+}
+
+styles = {
+	'legacy': legacy_style,
+	'modern': modern_style,
+}
+
+
+styleguide = legacy_style
+
 
 def indent_up():
 	global indent_level
@@ -17,13 +37,11 @@ def indent_down():
 	indent_level = indent_level - 1
 
 
-
 def set_nl_symbol(x):
 	global nl_symbol
 	nl_symbol = x
 
 
-
 def str_indent():
 	global indent_level
 	global indent_symbol
@@ -37,41 +55,12 @@ def str_nl_indent(nl=1):
 	return s
 
 
-
-
-
-
-
-
-legacy_style = {
-	'LINE_BREAK_BEFORE_STRUCT_BRACE': False,
-	'LINE_BREAK_BEFORE_FUNC_BRACE': False,
-	'LINE_BREAK_BEFORE_BLOCK_BRACE': False,
-}
-
-modern_style = {
-	'LINE_BREAK_BEFORE_STRUCT_BRACE': True,
-	'LINE_BREAK_BEFORE_FUNC_BRACE': True,
-	'LINE_BREAK_BEFORE_BLOCK_BRACE': True,
-}
-
-styles = {
-	'legacy': legacy_style,
-	'modern': modern_style,
-}
-
-
-# default style is legacy
-styleguide = legacy_style
-
-
-def render(node, style='legacy', indent='\t', newline='\n'):
+def render(node, style='legacy', indent='\t'):
 	global indent_level, styleguide, nl_symbol, indent_symbol
 
 	saved = (indent_level, styleguide, nl_symbol, indent_symbol)
 	indent_level = 0
 	styleguide = styles[style]
-	nl_symbol = newline
 	indent_symbol = indent
 
 	try:
@@ -94,9 +83,9 @@ def wrap_if(x, cond):
 	return "(%s)" % x if cond else x
 
 
-def str_specs(specs):
+def str_specs(specifiers):
 	s = ''
-	for opt in specs:
+	for opt in specifiers:
 		s += opt + ' '
 	return s
 
@@ -107,8 +96,6 @@ def with_space(s):
 	return ''
 
 
-
-
 def str_gcc_attributes(attributes):
 	if attributes == None:
 		return ''
@@ -153,17 +140,12 @@ def str_gcc_attributes(attributes):
 
 
 
-
-
-
-
-
 class CField():
-	def __init__(self, id_str, type, specs=None, nl=0):
+	def __init__(self, id, type, specifiers=None, nl=0):
 		#assert(isinstance(type, CType))
-		self.id_str = id_str
+		self.id = id
 		self.type = type
-		self.specs = specs if specs != None else []
+		self.specifiers = specifiers if specifiers != None else []
 		self.nl = nl
 
 
@@ -177,12 +159,12 @@ class CType():
 		return "<type> " + text
 
 
-class CTypeNamed(CType):
-	def __init__(self, id_str, specs=None):
-		assert(isinstance(id_str, str))
+class CTypeIdentifier(CType):
+	def __init__(self, id, specifiers=None):
+		assert(isinstance(id, str))
 		super().__init__()
-		self.id_str = id_str
-		self.specs = specs if specs != None else []
+		self.id = id
+		self.specifiers = specifiers if specifiers != None else []
 		self.precedence = 0
 
 	def to_str(self, text='', with_qualifiers=True):
@@ -190,22 +172,22 @@ class CTypeNamed(CType):
 		sstr = ''
 		if with_qualifiers:
 			# for: const, volatile, restrict
-			sstr += str_specs(self.specs)
-		return sstr + self.id_str + with_space(text)
+			sstr += str_specs(self.specifiers)
+		return sstr + self.id + with_space(text)
 
 
 class CTypePointer(CType):
-	def __init__(self, to, specs=None):
+	def __init__(self, to, specifiers=None):
 		super().__init__()
 		self.to = to
-		self.specs = specs if specs != None else []
+		self.specifiers = specifiers if specifiers != None else []
 		self.precedence = 1
 
 	def to_str(self, text='', with_qualifiers=True):
 		# "*volatile p"
 		sstr = '*'
 		if with_qualifiers:
-			sstr += str_specs(self.specs)
+			sstr += str_specs(self.specifiers)
 		sstr += text
 		sstr = wrap_if(sstr, self.to.precedence > self.precedence)
 		sstr = str_ctype(self.to, sstr)
@@ -213,31 +195,31 @@ class CTypePointer(CType):
 
 
 class CTypeArray(CType):
-	def __init__(self, of, volume=None, specs=[]):
+	def __init__(self, item_type, size=None, specifiers=[]):
 		super().__init__()
-		of.specs = specs  # array specs is array item specs (!)
-		self.of = of
-		self.volume = volume
-		self.specs = specs if specs != None else []
+		item_type.specifiers = specifiers  # array specs is array item specs (!)
+		self.item_type = item_type
+		self.size = size
+		self.specifiers = specifiers if specifiers != None else []
 		self.precedence = 2
 
 	def to_str(self, text='', with_qualifiers=True):
 		text = text + '['
-		if self.volume != None:
-			text += str_cvalue(self.volume)
+		if self.size != None:
+			text += str_cvalue(self.size)
 		text += ']'
-		text = wrap_if(text, self.of.precedence > self.precedence)
-		text = str_ctype(self.of, text)
+		text = wrap_if(text, self.item_type.precedence > self.precedence)
+		text = str_ctype(self.item_type, text)
 		return text
 
 
-class CTypeFunc(CType):
-	def __init__(self, params, to, volume=None, extra_args=False, specs=None):
+class CTypeFunction(CType):
+	def __init__(self, params, to, size=None, extra_args=False, specifiers=None):
 		super().__init__()
 		self.params = params
 		self.to = to
 		self.extra_args = extra_args
-		self.specs = specs if specs != None else []
+		self.specifiers = specifiers if specifiers != None else []
 		self.precedence = 3
 
 	def to_str(self, text='', with_qualifiers=True):
@@ -246,7 +228,7 @@ class CTypeFunc(CType):
 		params = self.params
 		while i < len(params):
 			param = params[i]
-			p = str_ctype(param.type, text=param.id_str)
+			p = str_ctype(param.type, text=param.id)
 			if i > 0:
 				params_text += ', ' + p
 			else:
@@ -265,11 +247,11 @@ class CTypeFunc(CType):
 
 
 class CTypeStruct(CType):
-	def __init__(self, fields, tag, specs=None):
+	def __init__(self, fields, tag, specifiers=None):
 		super().__init__()
 		self.fields = fields
 		self.tag = tag
-		self.specs = specs if specs != None else []
+		self.specifiers = specifiers if specifiers != None else []
 		self.precedence = 0
 
 	def to_str(self, text='', with_qualifiers=True):
@@ -295,7 +277,7 @@ class CTypeStruct(CType):
 						sstr += ' '
 
 				sstr += str_nl_indent(field.nl)
-				sstr += str_ctype(field.type, text=field.id_str) + ';'
+				sstr += str_ctype(field.type, text=field.id) + ';'
 				i = i + 1
 		else:
 			sstr += 'uint8_t __placeholder;'
@@ -305,7 +287,8 @@ class CTypeStruct(CType):
 
 
 
-class CTypeEnumItem():
+
+class CEnumItem():
 	def __init__(self, id, value=None):
 		assert(isinstance(id, str))
 		assert(value == None or isinstance(value, CValue))
@@ -321,11 +304,11 @@ class CTypeEnumItem():
 
 
 class CTypeEnum(CType):
-	def __init__(self, items, tag='', specs=None):
+	def __init__(self, items, tag='', specifiers=None):
 		super().__init__()
 		self.items = items
 		self.tag = tag
-		self.specs = specs if specs != None else []
+		self.specifiers = specifiers if specifiers != None else []
 		self.precedence = 0
 
 	def to_str(self, text='', with_qualifiers=True):
@@ -342,7 +325,7 @@ class CTypeEnum(CType):
 
 		while i < nitems:
 			item = self.items[i]
-			assert(isinstance(item, CTypeEnumItem))
+			assert(isinstance(item, CEnumItem))
 			if item.nl > 0:
 				nl_end = 1
 
@@ -406,25 +389,26 @@ class KV():
 
 
 class CValue():
-	def __init__(self):
+	def __init__(self, nl=0):
 		self.mark = None
+		self.nl = nl
 
 
-class CValueNamed(CValue):
-	def __init__(self, id_str):
-		super().__init__()
-		self.id_str = id_str
+class CValueIdentifier(CValue):
+	def __init__(self, id, nl=0):
+		super().__init__(nl=nl)
+		self.id = id
 		self.precedence = 15
 
 	def __str__(self):
-		return self.id_str
+		return self.id
 
 
 
 
 class CValueInteger(CValue):
-	def __init__(self, number, as_hex=False, nsigns=0, suffix=''):
-		super().__init__()
+	def __init__(self, number, as_hex=False, nsigns=0, suffix='', nl=0):
+		super().__init__(nl=nl)
 		assert(isinstance(number, int))
 		assert(isinstance(as_hex, bool))
 		self.precedence = 15
@@ -452,9 +436,9 @@ def string_literal_prefix(width):
 
 
 class CValueString(CValue):
-	def __init__(self, string, width):
+	def __init__(self, string, width, nl=0):
 		assert(isinstance(string, str))
-		super().__init__()
+		super().__init__(nl=nl)
 		self.string = string
 		self.width = width
 		self.precedence = 15
@@ -486,9 +470,9 @@ def code_to_char(cc):
 
 
 class CValueChar(CValue):
-	def __init__(self, cc, width=8):
+	def __init__(self, cc, width=8, nl=0):
 		assert(isinstance(cc, int))
-		super().__init__()
+		super().__init__(nl=nl)
 		self.char_code = cc
 		self.width = width
 		self.precedence = 15
@@ -499,8 +483,8 @@ class CValueChar(CValue):
 
 
 class CValueArray(CValue):
-	def __init__(self, items):
-		super().__init__()
+	def __init__(self, items, nl=0):
+		super().__init__(nl=nl)
 		self.items = items
 		self.precedence = 15
 
@@ -531,8 +515,8 @@ class CValueArray(CValue):
 
 
 class CValueStruct(CValue):
-	def __init__(self, items):
-		super().__init__()
+	def __init__(self, items, nl=0):
+		super().__init__(nl=nl)
 		self.items = items
 		self.precedence = 15
 
@@ -571,15 +555,15 @@ class CValueStruct(CValue):
 
 
 
-class CValueSubexpr(CValue):
-	def __init__(self, value):
+class CValueParen(CValue):
+	def __init__(self, value, nl=0):
 		assert(isinstance(value, CValue))
-		super().__init__()
+		super().__init__(nl=nl)
 		self.value = value
 		self.precedence = 15
 
 	def __str__(self):
-		return '(%s)' % str_cvalue(self.value, ext_precedence=self.precedence)
+		return str_cvalue(self.value, ext_precedence=valuePrecedenceMax)
 
 
 
@@ -596,30 +580,30 @@ class CValueCall(CValue):
 		return '%s(%s)' % (str_cvalue(self.left, ext_precedence=self.precedence), print_list_items(self.args, str_cvalue))
 
 
-class CValueAccess(CValue):
-	def __init__(self, left, field_id_str):
-		assert(isinstance(field_id_str, str))
+class CValueFieldAccess(CValue):
+	def __init__(self, left, field_id):
+		assert(isinstance(field_id, str))
 		assert(isinstance(left, CValue))
 		super().__init__()
 		self.left = left
-		self.field_id_str = field_id_str
+		self.field_id = field_id
 		self.precedence = 14
 
 	def __str__(self):
-		return '%s.%s' % (str_cvalue(self.left, ext_precedence=self.precedence), self.field_id_str)
+		return '%s.%s' % (str_cvalue(self.left, ext_precedence=self.precedence), self.field_id)
 
 
-class CValueAccessPtr(CValue):
-	def __init__(self, left, field_id_str):
-		assert(isinstance(field_id_str, str))
+class CValuePtrFieldAccess(CValue):
+	def __init__(self, left, field_id):
+		assert(isinstance(field_id, str))
 		assert(isinstance(left, CValue))
 		super().__init__()
 		self.left = left
-		self.field_id_str = field_id_str
+		self.field_id = field_id
 		self.precedence = 14
 
 	def __str__(self):
-		return '%s->%s' % (str_cvalue(self.left, ext_precedence=self.precedence), self.field_id_str)
+		return '%s->%s' % (str_cvalue(self.left, ext_precedence=self.precedence), self.field_id)
 
 
 class CValueIndex(CValue):
@@ -650,7 +634,7 @@ class CValueCast(CValue):
 		return '(%s)%s' % (str_ctype(self.type, with_qualifiers=False), vstr)
 
 
-class CValueRef(CValue):
+class CValueReference(CValue):
 	def __init__(self, value):
 		assert(isinstance(value, CValue))
 		super().__init__()
@@ -661,7 +645,7 @@ class CValueRef(CValue):
 		return '&%s' % str_cvalue(self.value, ext_precedence=self.precedence)
 
 
-class CValueDeref(CValue):
+class CValueDereference(CValue):
 	def __init__(self, value):
 		assert(isinstance(value, CValue))
 		super().__init__()
@@ -672,29 +656,7 @@ class CValueDeref(CValue):
 		return '*%s' % str_cvalue(self.value, ext_precedence=self.precedence)
 
 
-class CValueInc(CValue):
-	def __init__(self, value):
-		assert(isinstance(value, CValue))
-		super().__init__()
-		self.value = value
-		self.precedence = 13
-
-	def __str__(self):
-		return '++%s' % (str_cvalue(self.value, ext_precedence=self.precedence))
-
-
-class CValueDec(CValue):
-	def __init__(self, value):
-		assert(isinstance(value, CValue))
-		super().__init__()
-		self.value = value
-		self.precedence = 13
-
-	def __str__(self):
-		return '--%s' % str_cvalue(self.value, ext_precedence=self.precedence)
-
-
-class CValuePositive(CValue):
+class CValueUnaryPlus(CValue):
 	def __init__(self, value):
 		assert(isinstance(value, CValue))
 		super().__init__()
@@ -705,7 +667,7 @@ class CValuePositive(CValue):
 		return '+%s' % (str_cvalue(self.value, ext_precedence=self.precedence))
 
 
-class CValueNegative(CValue):
+class CValueUnaryMinus(CValue):
 	def __init__(self, value):
 		assert(isinstance(value, CValue))
 		super().__init__()
@@ -716,7 +678,7 @@ class CValueNegative(CValue):
 		return '-%s' % (str_cvalue(self.value, ext_precedence=self.precedence))
 
 
-class CValueNotLogical(CValue):
+class CValueLogicalNot(CValue):
 	def __init__(self, value):
 		assert(isinstance(value, CValue))
 		super().__init__()
@@ -727,7 +689,7 @@ class CValueNotLogical(CValue):
 		return '!%s' % (str_cvalue(self.value, ext_precedence=self.precedence))
 
 
-class CValueNotBitwise(CValue):
+class CValueBitwiseNot(CValue):
 	def __init__(self, value):
 		assert(isinstance(value, CValue))
 		super().__init__()
@@ -771,7 +733,7 @@ class CValueMul(CValue):
 
 	def __str__(self):
 		lx = str_cvalue(self.left, ext_precedence=self.precedence)
-		rx = str_cvalue(self.right, ext_precedence=self.precedence)
+		rx = str_cvalue(self.right, ext_precedence=self.precedence + 1)
 		return '%s * %s' % (lx, rx)
 
 
@@ -786,11 +748,11 @@ class CValueDiv(CValue):
 
 	def __str__(self):
 		lx = str_cvalue(self.left, ext_precedence=self.precedence)
-		rx = str_cvalue(self.right, ext_precedence=self.precedence)
+		rx = str_cvalue(self.right, ext_precedence=self.precedence + 1)
 		return '%s / %s' % (lx, rx)
 
 
-class CValueRem(CValue):
+class CValueMod(CValue):
 	def __init__(self, left, right):
 		assert(isinstance(left, CValue))
 		assert(isinstance(right, CValue))
@@ -801,7 +763,7 @@ class CValueRem(CValue):
 
 	def __str__(self):
 		lx = str_cvalue(self.left, ext_precedence=self.precedence)
-		rx = str_cvalue(self.right, ext_precedence=self.precedence)
+		rx = str_cvalue(self.right, ext_precedence=self.precedence + 1)
 		return '%s %% %s' % (lx, rx)
 
 
@@ -816,7 +778,7 @@ class CValueAdd(CValue):
 
 	def __str__(self):
 		lx = str_cvalue(self.left, ext_precedence=self.precedence)
-		rx = str_cvalue(self.right, ext_precedence=self.precedence)
+		rx = str_cvalue(self.right, ext_precedence=self.precedence + 1)
 		return '%s + %s' % (lx, rx)
 
 
@@ -831,11 +793,11 @@ class CValueSub(CValue):
 
 	def __str__(self):
 		lx = str_cvalue(self.left, ext_precedence=self.precedence)
-		rx = str_cvalue(self.right, ext_precedence=self.precedence)
+		rx = str_cvalue(self.right, ext_precedence=self.precedence + 1)
 		return '%s - %s' % (lx, rx)
 
 
-class CValueShl(CValue):
+class CValueShiftLeft(CValue):
 	def __init__(self, left, right):
 		assert(isinstance(left, CValue))
 		assert(isinstance(right, CValue))
@@ -850,7 +812,7 @@ class CValueShl(CValue):
 		lprec = self.precedence
 		if self.left.precedence == self.precedence + 1:
 			lprec = valuePrecedenceMax
-		rprec = self.precedence
+		rprec = self.precedence + 1
 		if self.right.precedence == self.precedence + 1:
 			rprec = valuePrecedenceMax
 
@@ -859,7 +821,7 @@ class CValueShl(CValue):
 		return '%s << %s' % (lx, rx)
 
 
-class CValueShr(CValue):
+class CValueShiftRight(CValue):
 	def __init__(self, left, right):
 		assert(isinstance(left, CValue))
 		assert(isinstance(right, CValue))
@@ -874,7 +836,7 @@ class CValueShr(CValue):
 		lprec = self.precedence
 		if self.left.precedence == self.precedence + 1:
 			lprec = valuePrecedenceMax
-		rprec = self.precedence
+		rprec = self.precedence + 1
 		if self.right.precedence == self.precedence + 1:
 			rprec = valuePrecedenceMax
 
@@ -894,7 +856,7 @@ class CValueLt(CValue):
 
 	def __str__(self):
 		lx = str_cvalue(self.left, ext_precedence=self.precedence)
-		rx = str_cvalue(self.right, ext_precedence=self.precedence)
+		rx = str_cvalue(self.right, ext_precedence=self.precedence + 1)
 		return '%s < %s' % (lx, rx)
 
 
@@ -909,7 +871,7 @@ class CValueGt(CValue):
 
 	def __str__(self):
 		lx = str_cvalue(self.left, ext_precedence=self.precedence)
-		rx = str_cvalue(self.right, ext_precedence=self.precedence)
+		rx = str_cvalue(self.right, ext_precedence=self.precedence + 1)
 		return '%s > %s' % (lx, rx)
 
 
@@ -924,7 +886,7 @@ class CValueLE(CValue):
 
 	def __str__(self):
 		lx = str_cvalue(self.left, ext_precedence=self.precedence)
-		rx = str_cvalue(self.right, ext_precedence=self.precedence)
+		rx = str_cvalue(self.right, ext_precedence=self.precedence + 1)
 		return '%s <= %s' % (lx, rx)
 
 
@@ -939,7 +901,7 @@ class CValueGE(CValue):
 
 	def __str__(self):
 		lx = str_cvalue(self.left, ext_precedence=self.precedence)
-		rx = str_cvalue(self.right, ext_precedence=self.precedence)
+		rx = str_cvalue(self.right, ext_precedence=self.precedence + 1)
 		return '%s >= %s' % (lx, rx)
 
 
@@ -954,7 +916,7 @@ class CValueEq(CValue):
 
 	def __str__(self):
 		lx = str_cvalue(self.left, ext_precedence=self.precedence)
-		rx = str_cvalue(self.right, ext_precedence=self.precedence)
+		rx = str_cvalue(self.right, ext_precedence=self.precedence + 1)
 		return '%s == %s' % (lx, rx)
 
 
@@ -969,7 +931,7 @@ class CValueNe(CValue):
 
 	def __str__(self):
 		lx = str_cvalue(self.left, ext_precedence=self.precedence)
-		rx = str_cvalue(self.right, ext_precedence=self.precedence)
+		rx = str_cvalue(self.right, ext_precedence=self.precedence + 1)
 		return '%s != %s' % (lx, rx)
 
 
@@ -982,7 +944,7 @@ def select_prio_plus(sp, xp, n=0):
 	return sp
 
 
-class CValueAndBitwise(CValue):
+class CValueBitwiseAnd(CValue):
 	def __init__(self, left, right):
 		assert(isinstance(left, CValue))
 		assert(isinstance(right, CValue))
@@ -993,11 +955,11 @@ class CValueAndBitwise(CValue):
 
 	def __str__(self):
 		lx = str_cvalue(self.left, ext_precedence=self.precedence)
-		rx = str_cvalue(self.right, ext_precedence=self.precedence)
+		rx = str_cvalue(self.right, ext_precedence=self.precedence + 1)
 		return '%s & %s' % (lx, rx)
 
 
-class CValueXorBitwise(CValue):
+class CValueBitwiseXor(CValue):
 	def __init__(self, left, right):
 		assert(isinstance(left, CValue))
 		assert(isinstance(right, CValue))
@@ -1008,11 +970,11 @@ class CValueXorBitwise(CValue):
 
 	def __str__(self):
 		lx = str_cvalue(self.left, ext_precedence=select_prio_plus(self.precedence, self.left.precedence, n=1))
-		rx = str_cvalue(self.right, ext_precedence=select_prio_plus(self.precedence, self.right.precedence, n=1))
+		rx = str_cvalue(self.right, ext_precedence=max(self.precedence + 1, select_prio_plus(self.precedence, self.right.precedence, n=1)))
 		return '%s ^ %s' % (lx, rx)
 
 
-class CValueOrBitwise(CValue):
+class CValueBitwiseOr(CValue):
 	def __init__(self, left, right):
 		assert(isinstance(left, CValue))
 		assert(isinstance(right, CValue))
@@ -1023,11 +985,11 @@ class CValueOrBitwise(CValue):
 
 	def __str__(self):
 		lx = str_cvalue(self.left, ext_precedence=select_prio_plus(self.precedence, self.left.precedence, n=2))
-		rx = str_cvalue(self.right, ext_precedence=select_prio_plus(self.precedence, self.right.precedence, n=2))
+		rx = str_cvalue(self.right, ext_precedence=max(self.precedence + 1, select_prio_plus(self.precedence, self.right.precedence, n=2)))
 		return '%s | %s' % (lx, rx)
 
 
-class CValueAndLogical(CValue):
+class CValueLogicalAnd(CValue):
 	def __init__(self, left, right):
 		assert(isinstance(left, CValue))
 		assert(isinstance(right, CValue))
@@ -1038,11 +1000,11 @@ class CValueAndLogical(CValue):
 
 	def __str__(self):
 		lx = str_cvalue(self.left, ext_precedence=self.precedence)
-		rx = str_cvalue(self.right, ext_precedence=self.precedence)
+		rx = str_cvalue(self.right, ext_precedence=self.precedence + 1)
 		return '%s && %s' % (lx, rx)
 
 
-class CValueOrLogical(CValue):
+class CValueLogicalOr(CValue):
 	def __init__(self, left, right):
 		assert(isinstance(left, CValue))
 		assert(isinstance(right, CValue))
@@ -1053,7 +1015,7 @@ class CValueOrLogical(CValue):
 
 	def __str__(self):
 		lx = str_cvalue(self.left, ext_precedence=select_prio_plus(self.precedence, self.left.precedence, n=1))
-		rx = str_cvalue(self.right, ext_precedence=select_prio_plus(self.precedence, self.right.precedence, n=1))
+		rx = str_cvalue(self.right, ext_precedence=max(self.precedence + 1, select_prio_plus(self.precedence, self.right.precedence, n=1)))
 		return '%s || %s' % (lx, rx)
 
 
@@ -1109,7 +1071,7 @@ class CValueVaCopy(CValue):
 
 
 # string concat
-class CValueCat(CValue):
+class CValueStringConcat(CValue):
 	def __init__(self, left, right):
 		assert(isinstance(left, CValue))
 		assert(isinstance(right, CValue))
@@ -1120,7 +1082,7 @@ class CValueCat(CValue):
 
 	def __str__(self):
 		lx = str_cvalue(self.left, ext_precedence=self.precedence)
-		rx = str_cvalue(self.right, ext_precedence=self.precedence)
+		rx = str_cvalue(self.right, ext_precedence=self.precedence + 1)
 		return lx + ' ' + rx
 
 
@@ -1158,7 +1120,7 @@ class CStmt():
 		pass
 
 
-class CStmtCommentLine(CStmt):
+class CStmtLineComment(CStmt):
 	def __init__(self, lines):
 		assert(isinstance(lines, list))
 		super().__init__()
@@ -1179,7 +1141,7 @@ class CStmtCommentLine(CStmt):
 		return sstr
 
 
-class CStmtCommentBlock(CStmt):
+class CStmtBlockComment(CStmt):
 	def __init__(self, text):
 		assert(isinstance(text, str))
 		super().__init__()
@@ -1212,7 +1174,7 @@ class CStmtBlock(CStmt):
 		return sstr
 
 
-class CStmtValueExpr(CStmt):
+class CStmtExpr(CStmt):
 	def __init__(self, value):
 		assert(isinstance(value, CValue))
 		super().__init__()
@@ -1224,7 +1186,7 @@ class CStmtValueExpr(CStmt):
 		return sstr + str_cvalue(self.value) + ';'
 
 
-class CStmtValueAssign(CStmt):
+class CStmtAssignment(CStmt):
 	def __init__(self, lvalue, rvalue):
 		assert(isinstance(lvalue, CValue))
 		assert(isinstance(rvalue, CValue))
@@ -1237,7 +1199,7 @@ class CStmtValueAssign(CStmt):
 		return sstr + "%s = %s;" % (str_cvalue(self.lvalue), str_cvalue(self.rvalue))
 
 
-class CStmtInc(CStmt):
+class CStmtIncrement(CStmt):
 	def __init__(self, value):
 		assert(isinstance(value, CValue))
 		super().__init__()
@@ -1247,7 +1209,7 @@ class CStmtInc(CStmt):
 		return str_nl_indent(self.nl) + "++%s;" % str_cvalue(self.value)
 
 
-class CStmtDec(CStmt):
+class CStmtDecrement(CStmt):
 	def __init__(self, value):
 		assert(isinstance(value, CValue))
 		super().__init__()
@@ -1259,7 +1221,7 @@ class CStmtDec(CStmt):
 
 class CStmtDeclType(CStmt):
 	def __init__(self, type, attributes=None):
-		assert(isinstance(type, CTypeNamed))
+		assert(isinstance(type, CTypeIdentifier))
 		super().__init__()
 		self.type = type
 		self.attributes = attributes
@@ -1272,33 +1234,33 @@ class CStmtDeclType(CStmt):
 
 
 class CStmtDefType(CStmt):
-	def __init__(self, id_str, type, attributes=None):
-		assert(isinstance(id_str, str))
+	def __init__(self, id, type, attributes=None):
+		assert(isinstance(id, str))
 		assert(isinstance(type, CType))
 		super().__init__()
-		self.id_str = id_str
+		self.id = id
 		self.type = type
 		self.attributes = attributes
 
 	def __str__(self):
 		sstr = str_nl_indent(self.nl)
 		sstr += str_gcc_attributes(self.attributes)
-		sstr += 'typedef %s;' % self.type.to_str(text=self.id_str)
+		sstr += 'typedef %s;' % self.type.to_str(text=self.id)
 		return sstr
 
 
 
 class CStmtDefVar(CStmt):
-	def __init__(self, id_str, type, init_value=None, storage_class='', attributes=None):
-		assert(isinstance(id_str, str))
+	def __init__(self, id, type, initializer=None, storage_class='', attributes=None):
+		assert(isinstance(id, str))
 		assert(isinstance(type, CType))
-		if init_value != None:
-			assert(isinstance(init_value, CValue))
+		if initializer != None:
+			assert(isinstance(initializer, CValue))
 		super().__init__()
-		self.id_str = id_str
+		self.id = id
 		self.type = type
 		self.storage = storage_class
-		self.init_value = init_value
+		self.initializer = initializer
 		self.attributes = attributes
 
 	def __str__(self):
@@ -1307,22 +1269,22 @@ class CStmtDefVar(CStmt):
 		if self.storage not in (None, ''):
 			sstr += self.storage + ' '
 		#mass
-		sstr += str_ctype(self.type, text=self.id_str)
-		if self.init_value != None:
-			sstr += ' = %s' % str_cvalue(self.init_value)
+		sstr += str_ctype(self.type, text=self.id)
+		if self.initializer != None:
+			sstr += ' = %s' % str_cvalue(self.initializer)
 		return sstr + ';'
 
 
 
 class CStmtDefFunc(CStmt):
-	def __init__(self, id_str, type, block, storage_class='', attributes=None):
-		assert(isinstance(id_str, str))
+	def __init__(self, id, type, block, storage_class='', attributes=None):
+		assert(isinstance(id, str))
 		assert(isinstance(type, CType))
 		assert(isinstance(block, CStmtBlock))
 		#if init_value != None:
 		#	assert(isinstance(init_value, CValue))
 		super().__init__()
-		self.id_str = id_str
+		self.id = id
 		self.type = type
 		self.storage = storage_class
 		self.block = block
@@ -1334,7 +1296,7 @@ class CStmtDefFunc(CStmt):
 		sstr += str_gcc_attributes(self.attributes)
 		if self.storage not in (None, ''):
 			sstr += self.storage + ' '
-		sstr += self.type.to_str(text=self.id_str)
+		sstr += self.type.to_str(text=self.id)
 
 		if styleguide['LINE_BREAK_BEFORE_FUNC_BRACE']:
 			sstr += str_nl_indent()
@@ -1347,49 +1309,49 @@ class CStmtDefFunc(CStmt):
 
 
 class CStmtIf(CStmt):
-	def __init__(self, value_cond, block_then, block_else):
-		assert(isinstance(value_cond, CValue))
-		assert(isinstance(block_then, CStmtBlock))
-		if block_else:
-			assert((isinstance(block_else, CStmtBlock) or isinstance(block_else, CStmtIf)))
+	def __init__(self, condition, then_block, else_block):
+		assert(isinstance(condition, CValue))
+		assert(isinstance(then_block, CStmtBlock))
+		if else_block:
+			assert((isinstance(else_block, CStmtBlock) or isinstance(else_block, CStmtIf)))
 		super().__init__()
-		self.value_cond = value_cond
-		self.block_then = block_then
-		self.block_else = block_else
+		self.condition = condition
+		self.then_block = then_block
+		self.else_block = else_block
 
 	def __str__(self):
 		sstr = str_nl_indent(self.nl)
-		sstr += "if (%s)" % str_cvalue(self.value_cond)
+		sstr += "if (%s)" % str_cvalue(self.condition)
 		if styleguide['LINE_BREAK_BEFORE_BLOCK_BRACE']:
 			sstr += str_nl_indent()
 		else:
 			sstr += ' '
-		sstr += str(self.block_then)
-		if self.block_else != None:
+		sstr += str(self.then_block)
+		if self.else_block != None:
 			if styleguide['LINE_BREAK_BEFORE_BLOCK_BRACE']:
 				sstr += str_nl_indent()
 			else:
 				sstr += ' '
 			sstr += 'else'
-			if isinstance(self.block_else, CStmtBlock) and styleguide['LINE_BREAK_BEFORE_BLOCK_BRACE']:
+			if isinstance(self.else_block, CStmtBlock) and styleguide['LINE_BREAK_BEFORE_BLOCK_BRACE']:
 				sstr += str_nl_indent()
 			else:
 				sstr += ' '
-			sstr += str(self.block_else)
+			sstr += str(self.else_block)
 		return sstr
 
 
 class CStmtWhile(CStmt):
-	def __init__(self, value_cond, block):
-		assert(isinstance(value_cond, CValue))
+	def __init__(self, condition, block):
+		assert(isinstance(condition, CValue))
 		assert(isinstance(block, CStmtBlock))
 		super().__init__()
-		self.value_cond = value_cond
+		self.condition = condition
 		self.block = block
 
 	def __str__(self):
 		sstr = str_nl_indent(self.nl)
-		sstr += "while (%s)" % str_cvalue(self.value_cond)
+		sstr += "while (%s)" % str_cvalue(self.condition)
 		if styleguide['LINE_BREAK_BEFORE_BLOCK_BRACE']:
 			sstr += str_nl_indent()
 		else:
@@ -1399,17 +1361,17 @@ class CStmtWhile(CStmt):
 
 
 class CStmtReturn(CStmt):
-	def __init__(self, value_retval):
-		if value_retval != None:
-			assert(isinstance(value_retval, CValue))
+	def __init__(self, return_value):
+		if return_value != None:
+			assert(isinstance(return_value, CValue))
 		super().__init__()
-		self.value_retval = value_retval
+		self.return_value = return_value
 
 	def __str__(self):
 		sstr = str_nl_indent(self.nl)
 		sstr += 'return'
-		if self.value_retval != None:
-			sstr += ' ' + str_cvalue(self.value_retval)
+		if self.return_value != None:
+			sstr += ' ' + str_cvalue(self.return_value)
 		return sstr + ";"
 
 
@@ -1442,7 +1404,7 @@ class CStmtContinue(CStmt):
 #	: clobbered registers/memory /* optional */
 #);
 
-class CStmtAsm(CStmt):
+class CStmtInlineAsm(CStmt):
 	def __init__(self, text, outputs, inputs, clobbers):
 		super().__init__()
 		assert(isinstance(text, str))
@@ -1481,7 +1443,7 @@ class CStmtAsm(CStmt):
 
 
 
-class CInsert(CStmt):
+class CRawText(CStmt):
 	def __init__(self, text):
 		super().__init__()
 		self.text = text
@@ -1491,7 +1453,7 @@ class CInsert(CStmt):
 		return self.text
 
 
-class CMacrodefinition():
+class CMacroDef():
 	def __init__(self, id, text=None):
 		assert(isinstance(id, str))
 		if text:
@@ -1510,7 +1472,7 @@ class CMacrodefinition():
 		return sstr
 
 
-class CMacrodefinitionValue():
+class CMacroDefValue():
 	def __init__(self, id, value):
 		assert(isinstance(id, str))
 		assert(isinstance(value, CValue))
@@ -1543,18 +1505,18 @@ class CMacroUndef():
 
 
 class CInclude():
-	def __init__(self, text, isglobal):
+	def __init__(self, text, is_system):
 		assert(isinstance(text, str))
-		assert(isinstance(isglobal, bool))
+		assert(isinstance(is_system, bool))
 		self.nl = 1  #!!! (because it is not CStmt...)
 		super().__init__()
 		self.text = text
-		self.isglobal = isglobal
+		self.is_system = is_system
 		self.mark = None
 
 	def __str__(self):
 		#sstr = str_nl_indent(self.nl)
-		if self.isglobal:
+		if self.is_system:
 			return "\n#include <%s>" % self.text
 		return "\n#include \"%s\"" % self.text
 
@@ -1565,7 +1527,7 @@ def str_cdef(x):
 
 
 # pairs = ("macro text", [<defs>])
-class CIfdefRegion():
+class CConditionalRegion():
 	def __init__(self, pairs, _else=None):
 		self.pairs = pairs
 		self._else = _else

{cshape-0.1.0 → cshape-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "cshape"
-version = "0.1.0"
+version = "0.2.2"
 description = "A dependency-free C AST + printer: build a tree in Python, get C11 source back"
 readme = "README.md"
 license = "MIT"

cshape-0.2.2/tests/test_smoke.py

@@ -0,0 +1,57 @@
+import unittest
+
+from cshape import (
+	CField, CStmtBlock, CStmtDefFunc, CStmtDefVar, CStmtReturn, CTypeArray,
+	CTypeFunction, CTypeIdentifier, CValueAdd, CValueArray, CValueIdentifier,
+	CValueInteger, render,
+)
+
+
+class SmokeTest(unittest.TestCase):
+	def test_render_function(self):
+		func = CStmtDefFunc(
+			id='add',
+			type=CTypeFunction(
+				params=[CField(id='a', type=CTypeIdentifier('int')),
+				        CField(id='b', type=CTypeIdentifier('int'))],
+				to=CTypeIdentifier('int'),
+			),
+			block=CStmtBlock([
+				CStmtReturn(CValueAdd(CValueIdentifier('a'), CValueIdentifier('b'))),
+			]),
+		)
+
+		self.assertEqual(
+			render(func).strip(),
+			'int add(int a, int b) {\n\treturn a + b;\n}',
+		)
+
+	def test_render_is_reentrant(self):
+		# render() must not leak indent/style state between independent calls
+		named = CTypeIdentifier('int')
+		render(named, style='modern')
+		self.assertEqual(render(named, style='legacy'), 'int')
+
+	def test_mark_shows_up_as_comment(self):
+		v = CValueIdentifier('x')
+		v.mark = 'debug-note'
+		self.assertIn('/*debug-note*/', render(v))
+
+	def test_value_constructor_accepts_nl_for_array_layout(self):
+		array_def = CStmtDefVar(
+			id='numbers',
+			type=CTypeArray(CTypeIdentifier('int')),
+			initializer=CValueArray([
+				CValueInteger(1, nl=1),
+				CValueInteger(2),
+			]),
+		)
+
+		self.assertEqual(
+			render(array_def).strip(),
+			'int numbers[] = {\n\t1, 2\n};',
+		)
+
+
+if __name__ == '__main__':
+	unittest.main()

cshape-0.1.0/tests/test_smoke.py

@@ -1,41 +0,0 @@
-import unittest
-
-from cshape import (
-	CField, CStmtBlock, CStmtDefFunc, CStmtReturn, CTypeFunc, CTypeNamed,
-	CValueAdd, CValueNamed, render,
-)
-
-
-class SmokeTest(unittest.TestCase):
-	def test_render_function(self):
-		func = CStmtDefFunc(
-			id_str='add',
-			type=CTypeFunc(
-				params=[CField(id_str='a', type=CTypeNamed('int')),
-				        CField(id_str='b', type=CTypeNamed('int'))],
-				to=CTypeNamed('int'),
-			),
-			block=CStmtBlock([
-				CStmtReturn(CValueAdd(CValueNamed('a'), CValueNamed('b'))),
-			]),
-		)
-
-		self.assertEqual(
-			render(func).strip(),
-			'int add(int a, int b) {\n\treturn a + b;\n}',
-		)
-
-	def test_render_is_reentrant(self):
-		# render() must not leak indent/style state between independent calls
-		named = CTypeNamed('int')
-		render(named, style='modern')
-		self.assertEqual(render(named, style='legacy'), 'int')
-
-	def test_mark_shows_up_as_comment(self):
-		v = CValueNamed('x')
-		v.mark = 'debug-note'
-		self.assertIn('/*debug-note*/', render(v))
-
-
-if __name__ == '__main__':
-	unittest.main()